home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / netBoot.new / sys / mapmem.c < prev    next >
C/C++ Source or Header  |  1990-12-19  |  8KB  |  247 lines
  1.  
  2. /*
  3.  * @(#)mapmem.c 1.1 86/09/27
  4.  * Copyright (c) 1986 by Sun Microsystems, Inc.
  5.  */
  6.  
  7. /*
  8.  * mapmem.c:  Map things the way the Monitor likes them.
  9.  *
  10.  * This is called from a temporary stack by assembler code just after
  11.  * diagnostics are finished.
  12.  */
  13.  
  14. #include "../sun3/sunmon.h"
  15. #include "../sun3/cpu.map.h"
  16. #include "../sun3/cpu.addrs.h"
  17. #include "../h/sunromvec.h"
  18. #include "../h/pginit.h"
  19. #include "../h/globram.h"
  20. #include "../h/enable.h"
  21. #include "../sun3/structconst.h"
  22.  
  23. /*
  24.  * Table of page map entries used to map on-board I/O and PROM pages.
  25.  */
  26. struct pginit mapinit[] = {
  27.     /*
  28.      * Initialization table for Sun-3 VME systems
  29.      */
  30. #ifdef PRISM
  31.     {(char *)PRISM_CFB_BASE, 1,
  32.         {1, PMP_SUP, VPM_MEMORY, 0, 0, MEMPG_PRISM_CFB}},
  33.         /*
  34.          * PRISM_CFB_BASE = 0xFD00000; base of color fb (virtual addr).
  35.          * MEMPG_PRISM_CFB = 0xFE800000 >> 13; physical page number.
  36.          */
  37. #endif PRISM
  38.     {(char *)KEYBMOUSE_BASE, 0,
  39.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_KBM}},
  40.  
  41.     {(char *)SERIAL0_BASE, 0,
  42.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_SERIAL0}},
  43.  
  44.     {(char *)EEPROM_BASE, 0,
  45.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_EEPROM}},
  46.  
  47.     {(char *)CLOCK_BASE, 0,
  48.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_CLOCK}},
  49.  
  50.     {(char *)MEMORY_ERR_BASE, 0,
  51.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_MEMORY_ERR}},
  52.  
  53.     {(char *)INTERRUPT_BASE, 0,
  54.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_INTERRUPT}},
  55.  
  56.     {(char *)ETHER_BASE, 0,
  57.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_ETHER}},
  58.  
  59.     {(char *)COLORMAP_BASE, 0,
  60.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_COLORMAP}},
  61.  
  62.     {(char *)AMD_ETHER_BASE, 0,
  63.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_AMD_ETHER}},
  64.  
  65.     {(char *)SCSI_BASE, 0,
  66.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_SCSI}},
  67.  
  68.     {(char *)DES_BASE, 0,
  69.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_DES}},
  70.  
  71.     {(char *)ECC_CTRL_BASE, 0,
  72.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_ECC_CTRL}},
  73.  
  74.     {((char *)ECC_CTRL_BASE)+BYTESPERPG, 0,        /* Unused */
  75.         {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  76.  
  77.     {VIDEOMEM_BASE, 1,        /* Video memory (if we have any) */
  78.         {1, PMP_SUP, VPM_MEMORY_NOCACHE, 0, 0, MEMPG_VIDEO}},
  79. #ifdef PRISM
  80.     {BW_ENABLE_MEM_BASE, 1,
  81.         {1, PMP_SUP, VPM_MEMORY, 0, 0, MEMPG_BW_ENABLE}},
  82. #endif PRISM
  83.  
  84.     {STACK_BASE, PGINITSKIP,     /* Skip this stuff, already set up */
  85.         {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  86.  
  87.     {MAINMEM_BITMAP, PGINITSKIP,     /* Skip this stuff, already set up */
  88.         {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  89.  
  90.     {BOOTMAP_BASE, 0,         /* Boot map area, invalid for now */
  91.         {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  92.  
  93.     {INVPMEG_BASE, 0,               /* Invalid pages, done later by hand */
  94.                 {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  95.  
  96.     {(char *)PROM_BASE, 0,        /* Prom space */
  97.         {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_PROM}},
  98.  
  99.     {((char *)PROM_BASE)+PROMSIZE, 0,    /* Invalid all the way */
  100.         {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  101.  
  102.     {(char *)(MONSHORTPAGE&MAPADDRMASK), PGINITEND,    /* End of table */
  103.         {0, PMP_RO_SUP, VPM_MEMORY, 0, 0, 0}},
  104. };
  105.  
  106. /*
  107.  * Initial mapping of memory:
  108.  *
  109.  * We set up a useful segment map, then a useful page map.
  110.  *
  111.  * We leave things in context 0.
  112.  * 
  113.  * This code takes no special care to avoid trashing its own stack,
  114.  * other than setting up segment 0 in each context safely before
  115.  * entering that context.  It assumes that its caller put its stack
  116.  * in segment 0 and knew what pmeg and pagemap it would eventually set
  117.  * its own stack to, to avoid unpleasant surprises.
  118.  */
  119. unsigned long
  120. mapmem(memsize)
  121.     unsigned long memsize;
  122. {
  123.     register char *i;
  124.     register unsigned short j;
  125.     register context_t con;
  126.  
  127.     /*
  128.      * Map segments of all contexts to pmegs.
  129.      *
  130.      * Address Range    Mapped To        Why
  131.      * 0x00000000    8M    Pmegs 0x00 - 0x40    Main Memory
  132.      * 0x00800000    246M    Invalid Pmeg        Big Hole
  133.      * 0x0FE00000    1M    Pmegs 0xFF - 0xF8    MONSTART->MONEND
  134.      * 0x0FF00000    512K    Pmegs 0xF7 - 0xF4    DVMA
  135.      * 0x0FF80000    384K    Invalid Pmeg        Little Hole
  136.      * 0x0FFE0000    128K    One Pmeg from F7-F0    MONSHORTSEG
  137.      *
  138.      * We want to use the last pmeg as the Invalid Pmeg, but we want
  139.      * to make the last virtual address usable, since it contains
  140.      * four of the eight pages addressable with Short Abs. addresses.
  141.      * To do this, we swap the last pmeg and the one that
  142.      * would normally be mapped at the virtual address of the Invalid
  143.      * Pmeg.
  144.      *
  145.      * For the Prism, we leave 1Mbyte (8 pmegs) just before MONSTART
  146.      * for the color frame buffer.
  147.      *
  148.      */
  149.     for (con = 0; con < NUMCONTEXTS; con++) {
  150.         setcxsegmap_noint(con, (char *)0, 0);
  151.         setcontext(con);
  152.         i = 0;
  153.         j = 0;
  154.         for (; i < (char *)MAINMEM_MAP_SIZE;i += PGSPERSEG * BYTESPERPG)
  155.             setsegmap(i, j++);
  156.         for (; i < (char *)MONBEG; i += PGSPERSEG * BYTESPERPG)
  157.             setsegmap(i, SEG_INVALID);
  158.  
  159.         j = SEG_INVALID - 1;            /* 0xFF - 1 = 0xFE */
  160.         for (; i < (char *)MONEND; i += PGSPERSEG * BYTESPERPG)
  161.             setsegmap(i, j--);
  162.         for (; i < (char *)DVMA_BASE+DVMA_MAP_SIZE;
  163.                         i += PGSPERSEG * BYTESPERPG)
  164.             setsegmap(i, j--);
  165.         for (; i < (char *)ADRSPC_SIZE;    i += PGSPERSEG * BYTESPERPG)
  166.             setsegmap(i, SEG_INVALID);
  167.  
  168.         j = getsegmap(INVPMEG_BASE);    /* INVPMEG_BASE=0xFE40000,
  169.                          * which is between MONSTART
  170.                          * and MONEND.
  171.                          */
  172.         setsegmap(INVPMEG_BASE, SEG_INVALID);
  173.         setsegmap(MONSHORTSEG, j);
  174.  
  175.     }
  176.     setcontext((context_t)0);
  177.  
  178.     /*
  179.      * Map all of memory according to initialization table
  180.      *
  181.      * First, we must map in the initialization table, since it's
  182.      * accessed as data.  We map two pages in case it spans a
  183.      * page boundary.
  184.      * 
  185.      * This code takes no special care to avoid trashing its own stack.
  186.      * It therefore assumes that its caller knew what page its would
  187.      * set its own stack to, and initialized the stack that way.
  188.      */
  189.     setpgmap(((char *)mapinit)           , PME_PROM); 
  190.     setpgmap(((char *)mapinit)+BYTESPERPG, PME_PROM);
  191.     setupmap(mapinit);        /* Initialize whole page map */
  192.  
  193.     /*
  194.      * Initialize the stolen RAM pages.
  195.      *
  196.      * These are taken from the last N pages of working memory.
  197.      *
  198.      * Note that MONBSS_BASE is defined in some header files to be
  199.      * same as MONSHORTPAGE which is defined as STRTDATA.
  200.      */
  201.  
  202.     setpgmap(STACK_BASE,  0xd0000000 + (memsize >> 13) - 1);
  203.         setpgmap(MONBSS_BASE, 0xd0000000 + (memsize >> 13) - 2);
  204.     
  205.     return (memsize - 2*BYTESPERPG);
  206. }
  207.  
  208.  
  209. /*
  210.  * This subroutine initializes large sections of the page map.
  211.  * It is called to initially set up the maps, and also called when
  212.  * setting up a "Sun-1 fake" environment.
  213.  *
  214.  * k points to the first element of an entry in table (e.g., KEYBMOUSE_BASE,
  215.  * SERIALO_BASE, etc.).  Each time the outer 'for' loop executes, k is pointing
  216.  * to the next entry.  If the 2nd element of an entry is PGINITEND, then the
  217.  * outer 'for' loop is not executed.  If it's 0 then only one page entry is
  218.  * is used (e.g., {1, PMP_SUP, VPM_IO, 0, 0, VIOPG_KBM} for KEYBMOUSE_BASE)
  219.  * for that device.  Note however, that even when it's 0 that the same entry
  220.  * may be entered into several locations of the page map, as is the case for
  221.  * PROM_BASE, which has 8 identical entries into the page map.  If the 2nd
  222.  * element is 1, then a new page entry is generated for each page of address
  223.  * space taken by that device (e.g., VIDEOMEM takes up 16 pages so it has
  224.  * 16 different entries (the actual difference between entries is the physical
  225.  * page number field of an entry) into the page table.
  226.  *
  227.  */
  228. setupmap(table)
  229.     struct pginit table[];
  230. {
  231.     register struct pginit *k;
  232.     char *i;
  233.     struct pgmapent pg;
  234.  
  235.     for (k = table; k->pi_incr != PGINITEND; k++) {
  236.         i = k->pi_addr;
  237.         pg = k->pi_pm;
  238.         if (k->pi_incr != PGINITSKIP) {
  239.             for (; i < k[1].pi_addr;
  240.                    i += BYTESPERPG, pg.pm_page += k->pi_incr) {
  241.                 setpgmap(i, pg);
  242.             }
  243.         }
  244.     }    /* end of for (k=table; ... ) */
  245. }    /* end of setupmap() */
  246.  
  247.